home *** CD-ROM | disk | FTP | other *** search
/ RISC User... in a Nutshell / RISC User... in a Nutshell.iso / !Nutshell / !OvnPro / Library / Imposition < prev    next >
Encoding:
Text File  |  1998-05-09  |  9.0 KB  |  471 lines
  1. // Imposition 1.00 
  2.  
  3.  
  4.  
  5.  
  6. int prgalley(int file,int keyn,int reason,int arg1,int arg2,int arg3)
  7. {
  8.  int width1;
  9.  
  10.  switch(reason)
  11.  {
  12.   case 0:
  13.          return(2);
  14.  
  15.   case 1:
  16.          paperarea(0,2*arg1,arg2,0,papermarks());
  17.          papermaxarea(-paperbleed(),2*arg1+paperbleed(),arg2+paperbleed(),-paperbleed());
  18.          return(0);
  19.  
  20.   case 2:
  21.   case 8:
  22.  case 10:
  23.          return(1+2+4);
  24.  
  25.   case 3:
  26.          return(scale(0x10000,arg2,2*arg1));
  27.  
  28.   case 4:
  29.          return(1);
  30.  
  31.   case 5:     
  32.          width1=maxpagewidth(file);
  33.  
  34.          if(arg3)
  35.          {
  36.           paperpage(0,width1-arg1,arg2,
  37.                       width1-arg1-paperbleed(),
  38.                       width1,
  39.                       arg2+paperbleed(),
  40.                                        -paperbleed(),0);
  41.          }
  42.          else
  43.          {
  44.           paperpage(0,width1,arg2,
  45.                       width1,
  46.                       width1+arg1+paperbleed(),
  47.                       arg2+paperbleed(),
  48.                                        -paperbleed(),0);
  49.  
  50.          }
  51.  
  52.          paperarea(0,2*width1,arg2,0,papermarks());
  53.          papermaxarea(-paperbleed(),2*width1+paperbleed(),
  54.                                   arg2+paperbleed(),-paperbleed());
  55.  
  56.          return(0);
  57.  
  58.   case 6:
  59.   case 7:
  60.   case 9:
  61.          return(0);
  62.  }
  63.  
  64.  return(0);
  65. }
  66.  
  67.  
  68. int prgalleycount(int file,int keyn,int paperbits)
  69. {
  70.  int paper;
  71.  
  72.  paper=papercount(1);
  73.  
  74.  if((paperbits & 0xF)!=2)
  75.  {
  76.   paper=((paper+0x3)&~0x3)/2;
  77.   paper/=2;
  78.  }
  79.  else
  80.  {
  81.   paper=((paper+1)&~0x1)/2; /* avoid trailing blank pages */
  82.  }
  83.  
  84.  return(paper);
  85. }
  86.  
  87.  
  88.  
  89. void prgalleysetup(int file,int keyn,int paperbits,int paperno,int nopaper)
  90. {
  91.  int bits;
  92.  int paper;
  93.  int parity;
  94.  int oddevenall;
  95.  int width1;
  96.  int side;
  97.  int step;
  98.  
  99.  paperfirstpage();
  100.  paper=0;
  101.  parity=1;
  102.  side=1;
  103.  step=1;
  104.  
  105.  width1=maxpagewidth(file);
  106.  
  107.  oddevenall=(paperbits & 0xF);
  108.  if(oddevenall==2)
  109.  {
  110.   nopaper/=2;
  111.   oddevenall=paperno & 0x1;
  112.   paperno/=2;
  113.  }
  114.  
  115.  
  116.  bits=papernextpage();
  117.  
  118.  if(bits) papermaxarea(-paperbleed(),2*width1+paperbleed(),
  119.                                       paperpageheight()+paperbleed(),-paperbleed());
  120.  
  121.  while(bits)
  122.  {
  123.   if(bits<0)
  124.   {
  125.    if((oddevenall==1 && !side) || (oddevenall==0 &&  side))
  126.    {
  127.     if(paper==paperno)
  128.     {
  129.      if((bits & 0x1)==parity)
  130.      {
  131.       paperarea(0,2*width1,paperpageheight(),0,papermarks());
  132.       papermaxarea(-paperbleed(),2*width1+paperbleed(),
  133.                                   paperpageheight()+paperbleed(),-paperbleed());
  134.  
  135.       if(!parity) /* right hand */
  136.       {
  137.        paperpage(1,width1,paperpageheight(),
  138.                                        width1,
  139.                                        width1+paperpagewidth()+paperbleed(),
  140.                                        paperpageheight()+paperbleed(),
  141.                                        -paperbleed(),0);
  142.        break;
  143.       }
  144.       else
  145.       {
  146.        paperpage(0,width1-paperpagewidth(),paperpageheight(),
  147.                                        width1-paperpagewidth()-paperbleed(),
  148.                                        width1,
  149.                                        paperpageheight()+paperbleed(),
  150.                                        -paperbleed(),0);
  151.       }
  152.      }
  153.     }
  154.    }
  155.  
  156.    if(!parity)    /* i.e. we have output a sheet of paper */
  157.    {
  158.     if(side==0) paper+=step;
  159.     side=1-side;
  160.    }
  161.  
  162.    if((bits & 0x1)==parity)
  163.    {
  164.     bits=papernextpage();
  165.    }
  166.    parity^=1;
  167.   }
  168.   else
  169.   {
  170.    bits=papernextpage();
  171.   }
  172.  }
  173. }
  174.  
  175.  
  176.  
  177. /*****************************************************************************/
  178.  
  179.  
  180.  
  181. int prpair(int file,int keyn,int reason,int arg1,int arg2,int arg3)
  182. {
  183.  if(reason==2) return(1);
  184.  else return(prgalley(file,keyn,reason,arg1,arg2,arg3));
  185. }
  186.  
  187.  
  188.  
  189. int prpamcount(int file,int keyn,int paperbits)
  190. {
  191.  int paper;
  192.  
  193.  paper=papercount(0);
  194.  
  195.  paper=((paper+0x3)&~0x3)/2;
  196.  if((paperbits & 0xF)!=2) paper/=2;
  197.  
  198.  return(paper);
  199. }
  200.  
  201.  
  202.  
  203. void prpamsetup(int file,int keyn,int paperbits,int paperno,int nopaper)
  204. {
  205.  int bits;
  206.  int paper;
  207.  int parity;
  208.  int oddevenall;
  209.  int width1;
  210.  int side;
  211.  int step;
  212.  
  213.  
  214.  paperfirstpage();
  215.  paper=0;
  216.  parity=0;
  217.  side=1;
  218.  step=1;
  219.  
  220.  width1=maxpagewidth(file);
  221.  
  222.  oddevenall=(paperbits & 0xF);
  223.  if(oddevenall==2)
  224.  {
  225.   nopaper/=2;
  226.   oddevenall=paperno & 0x1;
  227.   paperno/=2;
  228.  }
  229.  
  230.  
  231.  bits=papernextpage();
  232.  
  233.  if(bits) papermaxarea(-paperbleed(),2*width1+paperbleed(),
  234.                                        paperpageheight()+paperbleed(),-paperbleed());
  235.  
  236.  while(bits)
  237.  {
  238.   if(bits<0)
  239.   {
  240.    if((oddevenall==1 && !side) || (oddevenall==0 &&  side))
  241.    {
  242.     if(paper==paperno)
  243.     {
  244.      if((bits & 0x1)==parity)
  245.      {
  246.       if(!parity) /* right hand */
  247.       {
  248.        paperpage(1,width1,paperpageheight(),
  249.                                        width1,
  250.                                        width1+paperpagewidth()+paperbleed(),
  251.                                        paperpageheight()+paperbleed(),
  252.                                        -paperbleed(),0);
  253.       }
  254.       else
  255.       {
  256.        paperpage(0,width1-paperpagewidth(),paperpageheight(),
  257.                                        width1-paperpagewidth()-paperbleed(),
  258.                                        width1,
  259.                                        paperpageheight()+paperbleed(),
  260.                                        -paperbleed(),0);
  261.       }
  262.      }
  263.  
  264.      paperarea(0,2*width1,paperpageheight(),0,papermarks());
  265.      papermaxarea(-paperbleed(),2*width1+paperbleed(),
  266.                                   paperpageheight()+paperbleed(),-paperbleed());
  267.  
  268.      if(step<0) break;
  269.     }
  270.    }
  271.  
  272.    if(step>0)
  273.    {
  274.     if(side==0)
  275.     {
  276.      paper+=step;
  277.      if(paper==nopaper)
  278.      {
  279.       step=-1;
  280.       paper+=step;
  281.      }
  282.      else side=1;
  283.     }
  284.     else
  285.     {
  286.      side=0;
  287.     }
  288.    }
  289.    else
  290.    {
  291.     if(side==1)
  292.     {
  293.      paper+=step;
  294.      side=0;
  295.     }
  296.     else
  297.     {
  298.      side=1;
  299.     }
  300.    }
  301.  
  302.    if((bits & 0x1)==parity)
  303.    {
  304.     bits=papernextpage();
  305.    }
  306.    parity^=1;
  307.   }
  308.   else
  309.   {
  310.    bits=papernextpage();
  311.   }
  312.  }
  313. }
  314.  
  315.  
  316. /****************************************************************************/
  317.  
  318.  
  319.  
  320. int prnormal(int file,int keyn,int reason,int arg1,int arg2,int arg3)
  321. {
  322.  
  323.  switch(reason)
  324.  {
  325.   case 0:
  326.          return(1);
  327.  
  328.   case 1:
  329.          paperarea(0,arg1,arg2,0,papermarks());
  330.          papermaxarea(-paperbleed(),arg1+paperbleed(),arg2+paperbleed(),-paperbleed());
  331.          return(0);
  332.  
  333.   case 2:
  334.   case 8:
  335.  case 10:
  336.          return(2+4);
  337.  
  338.   case 3:
  339.          return(0x10000);
  340.  
  341.   case 4:
  342.          return(0);
  343.  
  344.   case 5:
  345.          paperarea(0,arg1,arg2,0,papermarks());
  346.          papermaxarea(-paperbleed(),arg1+paperbleed(),
  347.                                     arg2+paperbleed(),-paperbleed());
  348.  
  349.          paperpage(0,0,arg2,-paperbleed(),
  350.                                     arg1+paperbleed(),
  351.                                     arg2+paperbleed(),
  352.                                     -paperbleed(),0);
  353.          return(0);
  354.  
  355.   case 6:
  356.   case 7:
  357.   case 9:
  358.          return(0);
  359.  }
  360.  
  361.  return(0);
  362. }
  363.  
  364.  
  365.  
  366. int prnormalcount(int file,int keyn,int paperbits)
  367. {
  368.  int paper;
  369.  
  370.  paper=papercount(((paperbits & 0xF)==2)?-1:0);
  371.  
  372.  if((paperbits & 0xF)!=2) paper=((paper+1)&~0x1)/2;
  373.  
  374.  return(paper);
  375. }
  376.  
  377.  
  378.  
  379.  
  380. void prnormalsetup(int file,int keyn,int paperbits,int paperno,int nopaper)
  381. {
  382.  int bits;
  383.  int paper;
  384.  int parity;
  385.  
  386.  
  387.  paperfirstpage();
  388.  paper=0;
  389.  
  390.  if((paperbits & 0xF)==2) parity=-1;
  391.  else
  392.  if((paperbits & 0xF)==1) parity=1;
  393.  else                     parity=0;
  394.  
  395.  
  396.  bits=papernextpage();
  397.  
  398.  if(bits) papermaxarea(-paperbleed(),paperpagewidth()+paperbleed(),
  399.                                      paperpageheight()+paperbleed(),-paperbleed());
  400.  
  401.  while(bits)
  402.  {
  403.   if(bits<0)
  404.   {
  405.    if(((bits & 0x1)==parity) || parity<0)
  406.    {
  407.     if(paper==paperno)
  408.     {
  409.      paperarea(0,paperpagewidth(),paperpageheight(),0,papermarks());
  410.      papermaxarea(-paperbleed(),paperpagewidth()+paperbleed(),
  411.                                 paperpageheight()+paperbleed(),-paperbleed());
  412.   
  413.      paperpage(0,0,paperpageheight(),-paperbleed(),
  414.                                      paperpagewidth()+paperbleed(),
  415.                                      paperpageheight()+paperbleed(),
  416.                                      -paperbleed(),0);
  417.      break;
  418.     }
  419.     paper++;
  420.    }
  421.   }
  422.   bits=papernextpage();
  423.  }
  424. }
  425.  
  426.  
  427. /****************************************************************************/
  428.  
  429. int print_handle;
  430.  
  431. int print_entry(int entry,int subcode)
  432. {
  433.  if(subcode || getprintmode()!=entry) setprintmode(entry);
  434.  return(0);
  435. }
  436.  
  437. int print_flags(int entry,string & text)
  438. {
  439.  return(entry==getprintmode());
  440. }
  441.  
  442. int print_menu(int open)
  443. {
  444.  return(print_handle);
  445. }
  446.  
  447.  
  448. void create_print_menu(void)
  449. {
  450.  print_handle=create_menu("{PRM00}");
  451.  
  452.  addentry_menu(print_handle,"print_entry","print_flags","","","{PRM01}");
  453.  addentry_menu(print_handle,"print_entry","print_flags","","","{PRM02}");
  454.  addentry_menu(print_handle,"print_entry","print_flags","","","{PRM03}");
  455.  addentry_menu(print_handle,"print_entry","print_flags","","","{PRM04}");
  456. }
  457.  
  458.  
  459.  
  460.  
  461. void main(void)
  462. {
  463.  create_print_menu();
  464.  paperaddformat("{PRM01}",0,"prnormal","prnormalcount","prnormalsetup");
  465.  paperaddformat("{PRM02}",1,"prgalley","prpamcount","prpamsetup");
  466.  paperaddformat("{PRM03}",2,"prgalley","prgalleycount","prgalleysetup");
  467.  paperaddformat("{PRM04}",3,"prpair","prpamcount","prpamsetup");
  468. }
  469.  
  470.  
  471.